home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d12 / masm.arc / CRC.ASM < prev    next >
Encoding:
Assembly Source File  |  1985-03-07  |  4.5 KB  |  164 lines
  1. title XMODEM CRC Algorithm 8086 / Lattice C Compiler
  2. page ,132
  3. ;
  4. ;************************************************************************
  5. ;* CRCSUBS (Cyclic Redundancy Code Subroutines) version 1.20        *
  6. ;* 8086 Mnemonics                            *
  7. ;*                                    *
  8. ;*    8086 Version: Lattice C callable                *
  9. ;*                                    *
  10. ;*         These subroutines will compute and check a true 16-bit        *
  11. ;*    Cyclic Redundancy Code for a message of arbitrary length.    *
  12. ;*                                    *
  13. ;*    The  use  of this scheme will guarantee detection of all    *
  14. ;*    single and double bit errors, all  errors  with  an  odd    *
  15. ;*    number  of  error bits, all burst errors of length 16 or    *
  16. ;*    less, 99.9969% of all 17-bit error bursts, and  99.9984%    *
  17. ;*    of  all  possible  longer  error bursts.  (Ref: Computer    *
  18. ;*    Networks, Andrew S.  Tanenbaum, Prentiss-Hall, 1981)        *
  19. ;*                                    *
  20. ;*                                    *
  21. ;*    There are four entry points, which are used as follows:        *
  22. ;*                                    *
  23. ;*    clrcrc();                            *
  24. ;*    CLRCRC - A call to this entry resets the CRC accumulator.    *
  25. ;*         It must be called at the start of each message.    *
  26. ;*                                    *
  27. ;*         Entry Parameters: None.                *
  28. ;*                                    *
  29. ;*         Exit Conditions:  CRC accumulator cleared.        *
  30. ;*                                    *
  31. ;*    udcrc(c);                            *
  32. ;*    char c;                                *
  33. ;*    UPDCRC - A call to this entry updates the CRC accumulator.    *
  34. ;*         It must be called once for each byte in the        *
  35. ;*         message for which the CRC is being calculated.        *
  36. ;*                                    *
  37. ;*         Entry Parameters:       a byte to be included        *
  38. ;*                     in the CRC calculation.    *
  39. ;*                                    *
  40. ;*         Exit Conditions:  CRC accumulator updated.        *
  41. ;*                                    *
  42. ;*                                    *
  43. ;*    crc= fincrc();                            *
  44. ;*    unsigned crc;                            *
  45. ;*    FINCRC - A call to this entry finishes the CRC calculation    *
  46. ;*         for a message which is to be TRANSMITTED. It must    *
  47. ;*         be called after the last byte of the message has    *
  48. ;*         been passed thru UPDCRC. It returns the calculated    *
  49. ;*         CRC bytes, which must be transmitted as the final    *
  50. ;*         two bytes of the message.                *
  51. ;*                                    *
  52. ;*        Note that this returns a single 16 bit value;         *
  53. ;*        if transmitting bytes, it must be transmitted         *
  54. ;*        upper half first then lower half:            *
  55. ;*                                    *
  56. ;*            output (crc >> 8);                *
  57. ;*            output (crc);                    *
  58. ;*                                    *
  59. ;*                                    *
  60. ;*         Entry Parameters: None.                *
  61. ;*                                    *
  62. ;*         Exit Conditions:  calculated CRC bytes.        *
  63. ;*                                    *
  64. ;*    error= chkcrc();                        *
  65. ;*    int error;                            *
  66. ;*    CHKCRC - A call to this routine checks the CRC bytes of        *
  67. ;*         a RECEIVED message and returns a code to indicate    *
  68. ;*         whether the message was received correctly. It must    *
  69. ;*         be called after the message AND the two CRC bytes    *
  70. ;*         have been received AND passed thru UPDCRC.        *
  71. ;*                                    *
  72. ;*         Entry Parameters: None.                *
  73. ;*                                    *
  74. ;*         Exit Conditions:  0 if message ok.            *
  75. ;*                   non-zero if message garbled.        *
  76. ;*                                    *
  77. ;************************************************************************
  78. ;*                                    *
  79. ;*    Designed & coded by Paul Hansknecht, June 13, 1981        *
  80. ;*    Converted to 8086 mnemonics by T. Jennings 25 Jan 84        *
  81. ;*                                    *
  82. ;*    Copyright (c) 1981, Carpenter Associates            *
  83. ;*                Box 451                    *
  84. ;*                Bloomfield Hills, MI 48013            *
  85. ;*                313/855-3074                *
  86. ;*                                    *
  87. ;*    This program may be freely reproduced for non-profit use.    *
  88. ;*                                    *
  89. ;************************************************************************
  90. ;
  91. pgroup group prog
  92. dgroup group data
  93. ;
  94. ;Our very own little bit of data space.
  95. ;
  96. data segment word public 'data'
  97.  
  98. crc    dw (?)        ;calculated CRC,
  99.  
  100. data ends
  101.  
  102. prog segment byte public 'prog'
  103. assume cs:pgroup,ds:dgroup
  104.  
  105. public clrcrc,updcrc,fincrc,chkcrc
  106. page
  107. ;
  108. ;Initialize the CRC.
  109. ;
  110. clrcrc:    mov    crc,0
  111.     ret
  112.     RET
  113. ;
  114. ;Update the CRC with the new byte. The method used is 
  115. ;the CCITT polynomial:
  116. ;
  117. ;    x^16 + x^12 + x^5 + 1
  118. ;
  119. ;An alternate method often used in synchronous
  120. ;protocols is:
  121. ;
  122. ;    x^16 + x^15 + x^2 + 1
  123. ;
  124. ;Which can be generated by changing the XOR pattern
  125. ;from 1021 hex to 8005 hex.
  126. ;
  127. updcrc:
  128.     push    bp
  129.     mov    bp,sp
  130.     mov    bx,crc        ;BX == CRC a reg for speed,
  131.     mov    cx,8        ;CX == bits in a byte,
  132.     mov    ax,[bp+4]    ;AL == msg byte,
  133.  
  134. u1:    rcl    al,1        ;MSB -> carry,
  135.     rcl    bx,1        ;    -> CRC LSB,
  136.     jnc    u2
  137.     xor    bx,1021h
  138. u2:    loop    u1
  139.  
  140.     mov    crc,bx
  141.     pop    bp
  142.     ret
  143. ;
  144. ;Finish off the CRC.
  145. ;
  146. fincrc:
  147.     xor    ax,ax        ;do two zeros
  148.     push    ax
  149.     call    updcrc
  150.     call    updcrc
  151.     pop    ax
  152.     mov    ax,crc        ;return finished CRC
  153.     ret
  154. ;
  155. ;Check the calculated CRC. Return 0 if OK.
  156. ;
  157. chkcrc:
  158.     mov    ax,crc
  159.     ret
  160.  
  161. prog ends
  162.  
  163.     end
  164.